Graphical user interfaces (GUIs) are a required feature of very many computer application programs, because of the ease of use that they provide as compared with most alternatives. Users generally do not want to be required to know specific commands, operators, syntax rules, etc, and much work has been expended on developing user interfaces which alleviate the need for such knowledge.
Users of a GUI typically interact with icons and controls in a GUI by moving a mouse pointer and then clicking a mouse button when the pointer is over the icon or control, or using other input devices such as a keyboard, microphone, light pen, and the like. (Hereafter, the mouse is referred to as an example input device without implying any limitation to this device). To enable the user to invoke particular operations on a computer system, the user interface needs to provide selection mechanisms to the user. In a typical user interface environment, this may be achieved by defining user interface controls such as toolbar buttons which invoke an operation in response to user interaction, context menus and combination box controls that allow selection of particular actions or property values (e.g. font selection), entry fields that allow the setting of a string property (e.g. a Web page URL), check boxes, scrollable lists, and radio buttons. Such controls are very widely used within user interfaces. The programming code which implements them is typically written by a programmer as part of the task of application program development, or pre-defined controls are supplied by the operating system or development environment.
In the past, GUIs have tended to be standardised by GUI developers so that users can easily and quickly learn how to use a new product. The use of standard features minimises the amount of new and unfamiliar user interaction sequences and interface behaviour that must be learnt and so avoids user effort and frustration. Since many user interface controls such as those mentioned above have been given consistent behaviour and visual appearance across a great many applications, they are now easily recognised and used by computer users.
However, with the accelerating interest in the World Wide Web Internet service as a vehicle for providing access to a huge range of different material and in particular as an advertising medium, consistency of appearance is becoming less desirable. Companies each want their own Web site to be distinctive--to be more eye catching, more memorable and more animated than their competitors' sites. The same requirements for distinctiveness also increasingly apply to application programs which are sold for local installation. Thus, the traditional bland grey appearance of user interface controls is often undesirable and graphic designers are increasingly being employed to create more distinctive alternatives.
Whilst graphic designers are skilled in the creation of exciting visuals, they do not typically have the programming skills necessary to deploy those visuals in the way they (or their customers) might like. A large number of GUI builder products, comprising computer program products for assisting a user with GUI creation, are now commercially available. Although simplifying the task of creating a user interface, many existing GUI builder products still require significant programming skills for their use, and so creating an attractive and distinctive interface requires the combination of design skills and programming skills. The end result is often either an unsatisfactory compromise or a prohibitive cost.
Additionally, user interface creation is time consuming even for those who do have the relevant programming skills. If the programmer is required to fully define all user interface controls, including their functions, their state models comprising a set of states and state transitions, and their appearance attributes, then a considerable amount of coding is involved. As well as the undesirable effort, there is an additional problem that interface control functionality may be inconsistent between different applications if the interface controls are separately coded each time. Clearly, if the function of interface controls which appear to be the same differs between applications, the end user is left confused and may fail to use the controls properly.
Computer program developers are often forced, by time or resource constraints, to compromise the completeness of the state models for controls they build, or sometimes omit elements of the expected behaviour through ignorance, oversight or misunderstanding. This not only leads to possible errors, but also contributes to user frustration with the interface and reduces the ease of use of the resulting application.